Digital processor for simulating operation of a parallel processing array

ABSTRACT

A digital processor for simulating operation of a parallel processing array incorporates digital processing units (P 1  to P 8 ) communicating data to one another via addresses in memories (M 0  to M 8 ) and registers (R 11  to R 41 ). Each processing unit (e.g. P 1 ) is programmed to input data and execute a computation involving updating of a stored coefficient followed by data output. Each computation involves use of a respective set of data addresses for data input and output, and each processing unit (e.g. P 1 ) is programmed with a list of such sets employed in succession by that unit. On reaching the end of its list, the processing unit (e.g. P 1 ) repeats it. Each address set is associated with a conceptual internal cell location in the simulated array (10), and each list is associated with a respective sub-array of the simulated array (10). Data is input cyclically to the processor (40) via input/output ports (I/O 5  to I/O 8 ) of some of the processing units (P 5  to P 8 ). Each processing unit (e.g. P 1 ) executes its list of address sets within a cycle at a rate of one address set per subcycle. At the end of its list, each of the processing units (P 1  to P 8 ) has executed the functions associated with a conceptual respective sub-array of simulated cells (12), and the processor (40) as a whole has simulated operation of one cycle of a systolic array (10). Repeating the address set lists with further processor input provides successive simulated array cycles.

BACKGROUND OF THE INVENTION

1. Field of the Invention

This Invention relates to a digital processor for simulating operation of a parallel processing array, such as a systolic array.

2. Discussion of Prior Art

The field of parallel processing arrays was developed to overcome a well-known problem in conventional digital computers, the "Von Neumann bottleneck". This problem arises from the serial nature of conventional computers, in which program steps or Instructions are executed one at .a time and in succession. This means that the computer operating speed is restricted to the rate at which its central processing unit executes individual instructions.

To overcome the operating speed problem of conventional computers, parallel processors based on systolic array architectures have been developed One such is disclosed in British Patent No. OB 2, 151, 378B, which corresponds to U.S. Pat. No. 4,727,503. IL consists of a triangular array of internal and boundary cells. The boundary cells form the array diagonal and are interconnected via delay latches. The internal cells art in above-diagonal locations. The array includes nearest-neighbor cell interconnection lines defining rows and columns of cells. The cells are activated cyclically by a common system clock. Signal flow is along the rows and down the columns at the rate of one cell per clock cycle. Each cell executes a computational function on each clock cycle employing data input to the array and/or received from neighboring cells. Computation results are output to neighboring cells to provide input for subsequent computations. The computations of individual cells are comparatively simple, but the systolic array as a whole performs a much more complex calculation, and does so In a recursive manner at potentially high speed. In effect, the array subdivides the complex calculations into a series of much smaller cascaded calculations which are distributed over the array processing cells. An external control computer Is not required. The cells are clock-activated, each operates on every clock cycle. The maximum clock frequency or rate of processing is limited only by the rate at which the slowest individual cell can carry out its comparatively simple processing function. This results in a high degree of parallelism, with potentially high speed if fast processing cells are employed. The "bottleneck" of conventional computers is avoided.

The disadvantage of prior art systolic arrays is that, in all but the simplest problems, large numbers of cells are required. As will be described later in more detail, a prior art triangular array for dealing with an n-dimensional computation requires in the order of n² /2 internal cells. In consequence, the number of internal cells required grows as the square of the number of dimensions of the computation. The number of boundary cells grows only linearly with number of dimensions. One important application of a triangular systolic array relates to processing signals from an array of sensors, such as a phased array of radar antennas. Typical radar phased arrays incorporate in the region of one thousand or more antennas, and a systolic array to process the antenna signals would require of the order of one million processing cells. Each cell requires the processing functions and connectivity capabilities of a transputer to enable communications between neighboring cells. Special purpose integrated circuits could also be used, in which "cells" constitute respective areas of a silicon chip or wafer. Since transputers are priced in excess of approximately $150 each, the cost of a systolic array would be prohibitively expensive for radar phased array purposes. It is also prohibitively expensive for many other signal processing applications characterized by high dimensionality.

There is a need for digital processing apparatus which has a degree of parallelism to overcome conventional computer disadvantages, but which requires fewer processing cells than a prior art systolic array.

It is known from EP-A-0 021 404 to employ an array of specially designed processors in a computer system for the simulation of logic operations. These processors operate in parallel. However, this prior art parallel array is disadvantageous in that data flow through it requires a multi-way switch operated by a computer. For i processors, the switch is i-by-i-way so that each processor can be connected to each of the others under computer control. This is not compatible with a systolic array architecture, in which (a) there is no controlling computer, (b) data flow paths in the array are fixed, (c) data flow is between nearest neighbors, (d) there are no external control instructions, and (e) conventional general purpose processors (eg transputers) may be used with programming to execute fairly straightforward arithmetic functions. Indeed, a major objective of systolic array architectures is to avoid the need for a controlling computer.

U.S. Pat. No. 4,622,632 to Tanimoto et al. relates to a pattern matching device which employs arrays of processors for operating on pyramidal data structures. Here the processors operate under the control of what is said to be a "controller", by which is presumably meant a control computer. The controller provides instructions to each of the processors in synchrony. The instructions both provide data store addresses and dictate which of its various processing functions an individual processor employs. Each processor performs a read-modify-write cycle in which data in a memory module is written back out to the same address from which it was obtained. As discussed above for EP-A-0,021,404, this is not compatible with a systolic array architecture, in which (a) there is no controlling computer, (b) data flow paths in the array are fixed, (c) data flow is between nearest neighbors, and (d) there are no external control instructions.

SUMMARY OF THE INVENTION

It is an object of the present invention to provide a digital processor suitable for simulating operation of a parallel processing array such as a systolic array.

The present invention provides a digital data processor for simulating operation of a parallel processing array, the processor including an assembly of digital processing devices connected to data storing means, characterized in that:

(a) each processing device is programmed to implement a respective list of sets of storing means data addresses;

(b) each address set contains input data addresses and output data addresses which differ, and each such set corresponds to data input/output functions of a respective simulated array cell;

(c) each list of address sets corresponds to a respective sub-array of cells of the simulated array, and each such list contains pairs of successive address sets in which the leading address sets have input data addresses like to output data addresses of respective successive address sets, each list being arranged to provide for operations associated with simulated cells to be executed in reverse order to that corresponding to data flow through the simulated array; and

(d) each processing device is programmed to employ a respective first address set to read input data from and write output data to the data storing means, the output data being generated in accordance with a computational function, to employ subsequent address sets in a like manner until the list is complete, and then to repeat this procedure cyclically.

The invention provides the advantage that it requires a reduced number of processing devices compared to a prior art array (such as a systolic array) which it simulates. The reduction is in proportion to the number of address sets per list. Each processing device is in effect allocated the functions of a number or sub-array of similated array cells, and is programmed to execute the functions of a number of these cells in succession and then repeat. The simulated array operation is therefore carried out, albeit at a reduced rate. However, a degree of parallelism is preserved because the overall computation is distributed over an assembly of individual processing devices. In consequence, the parallelism advantage over a conventional computer is retained. The invention might be referred to as a semi-parallel processor.

The invention may be arranged so that each processing device communicates with not more than four other processing devices; it may then incorporate storing means including register devices and memories connected between respective pairs of processing devices. The invention may incorporate storing means arranged to resolve addressing conflicts; preferably however the address lists are arranged such that each register device and memory is addressed by not more than one processing device at a time. Some of the processing devices may be arranged to communicate with two of the other processing devices via respective register devices. In this case the address set lists are arranged such that the register devices are addressed less frequently than the memories.

Each processing device may be arranged to store and update a respective coefficient in relation to each address set in its list.

The invention may incorporate processing devices with input means arranged for parallel to serial conversion of input data elements. This enables the processor to implement simultaneous input as in the systolic array which it simulates.

BRIEF DESCRIPTION OF THE DRAWINGS

In order that the invention might be more fully understood, embodiments thereof will now be described, by way of example only, with reference to the accompanying drawings, in which:

FIGS. 1, 2 and 3 illustrate the construction and mode of operation of a prior art systolic array;

FIG. 4 is a block diagram of a processor of the invention arranged to simulate part of the FIG. I array and incorporating eight processing units;

FIG. 5 illustrates the mode of operation of the FIG. 4 processor mapped on to the FIG. 1 array;

FIG. 6 illustrates read and write functions of a processing unit incorporated in the FIG. 4 processor;

FIG. 7 illustrates memory and programming arrangements associated with individual processing units in the FIG. 4 processor;

FIG. 8 schematically illustrates memory addressing in the FIG. 4 processor;

FIG. 9 is a block diagram of an input/output port for a processing unit:

FIG. 10 and 11 illustrate the construction and mode of operation of an alternative embodiment of the invention incorporating an odd number of processing units; and

FIG. 12 illustrates the mode of operation of a further embodiment of the invention incorporating four processing devices.

DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS

Referring to FIG. 1, a prior art triangular systolic array 10 is shown schematically. The array 10 is of the kind disclosed in British Patent No. 2,151,378B (U.S. Pat. No. 4,727,503). It includes a 15×15 above-diagonal sub-array of internal cells indicated by squares 12. A linear chain of fifteen boundary cells 14 shown as circles forms the triangular array diagonal. Adjacent boundary cells 14 are interconnected via one-cycle delay cells or latches indicated by dots 16. A multiplier cell 18 is connected to the lowermost internal and boundary cells 12 and 14. Each of the cells 12 to 18 is activated by a system clock (not shown), and the cells 12 to 16 carry out prearranged computations on each clock cycle. Input to the array 10 is from above as indicated by arrows 20. Horizontal outputs from boundary cells 14 pass along array rows as indicated by intercell arrows 22. Outputs from internal cells 12 pass down array columns as indicated by vertical intercell arrows 24. Boundary cells 14 have diagonal inputs and outputs such as 26 and 28 interconnected along the array diagonal via latches 16.

Referring now also to FIG. 2, the processing functions of the internal and boundary cells 12 and 14 are shown in greater detail. On each clock cycle, each boundary cell 14 receives an input value x_(in) from above. It employs a stored coefficient r together with x_(in) to Compute cosine and sine rotation parameters c and s and an updated value of r in accordance with:

    r'= r.sup.2 +x.sub.in.sup.2 !.sup.1/2                      (1)

For X_(in) =0, c=1 and s=0; otherwise:

    c=r/r', s=x.sub.in /r'                                     (2)

and

    r(updated)-r'                                              (3)

The parameters c and s are output horizontally to a neighboring internal cell 12 to the right.

Each boundary cell 14 also multiplies an upper left diagonal input 6 in by the parameter c to provide a lower right diagonal output bout

i.e.

    δ.sub.out =cδ.sub.in                           (4)

This provides for cumulative multiplication of c parameters along the array diagonal.

On each clock cycle, each internal cell 12 receives input of c and s parameters from the left and x_(in) from above. It computes x_(out) and updates its stored coefficient r in accordance with:

    x.sub.out =-sr+cx.sub.in                                   (5)

    r(updated)=cr+sx.sub.in                                    (6)

Data input to the array 10 is illustrated schematically in FIG. 3, in which the vertical dimension is shown foreshortened for illustrational convenience. FIG. 3 shows a first vector x₁ and a first element y₁ in the process of input to the array 10. The vector x₁ has fifteen elements x₁₁ to x₁,15, and is the leading row of a data matrix X. A column vector y is input to the rightmost array column. The vector y has elements Y₁, Y₂ . . . , and the nth element Y_(n) appears as an extension of the nth row x_(n1) to x_(n),15 of the data matrix X. As illustrated, y₁ extends x₁.

The first element x₁₁ of the first input vector x₁ is input to the top row (leftmost) boundary cell 14. Successive elements x₁₂, x₁₃, etc of x₁ are input to successive top row internal cells 12 with a temporal skew. Temporal skews are well known in the art of systolic arrays. In the present case the skew is a delay of one clock cycle between input to adjacent top row cells of elements of like vectors. The skew increases linearly to the right, so that input of the ith element x_(ni) of the nth vector x_(n) to the ith column of the array 10 lags input of x_(n1) to the first column by (i-1) clock cycles.

When x₁₁ is input to the uppermost boundary cell 14, it is employed to compute rotation parameters c, s for transforming the first vector x₁ into a rotated vector having a leading element of zero. On the clock cycle following input of x₁₁ to the uppermost boundary cell 14, X₁₂ is input to its row neighbor internal cell 12 in synchronism with input of c, s computed from x₁₁. One clock cycle later, the parameters c, s derived from x₁₁ reach the third cell from the left in the top row and are used to operate on x₁₃. In this manner, c,s computed from x₁₁ are employed to operate on elements x₁₂ to x₁,15 and y₁ on successive clock cycles. This produces a rotated version of x₁ from which x₁₁ is eliminated, the version passing to the second processor row. A similar procedure occurs in the second row, ie the rotated version of x₁₂ is used to compute c and s values for operation on the rotated versions of x₁₃ to x₁,15 and y₁. This procedure continues down the processor rows until all x-vector elements have been eliminated.

Subsequent data vectors x₂, x₃ etc representing further rows of the data matrix X are processed in the same way as x₁ by input to the uppermost array row. In general, the ith element x_(ni) of the nth data vector x_(n) is input to the ith array column on the (n+i+1) th clock cycle. Similarly, the nth element y_(n) of the column vector y is rotated in each row as though it were an additional element of the nth data vector x_(n). Each cumulatively rotated version of y_(n) passes to the multiplier cell 18. Here it is multiplied by the cumulatively multiplied c rotation parameters derived from x_(n) and computed along the array boundary cell diagonal. The output of the multiplier cell 18 is the least squares residual e_(n) given by:

    e.sub.n =x.sub.n.sup.T w(n)+y.sub.n                        (7)

where:

x_(n) ^(T) is the transpose of x_(n), and

w_(n) is a weight vector computed over all x₁ to x_(n) to minimise the sum of the squares of e₁ to e_(n).

In more general mathematical terms, the array 10 carries out a QR decomposition of the data matrix X as described in the prior art; ie the rotation algorithm operates on X to generate a matrix Q such that: ##EQU1## where R is an upper right triangular matrix. The matrix elements r of R are stored on individual internal and boundary cells 12 and 14 in all but the rightmost array column, and are recomputed every clock cycle. At the end of computation, the elements r may be extracted from their storage locations and used to compute the weight vector explicitly.

FIGS. 1 to 3 exemplify a typical prior art systolic array arranged inter alia to carry out QR decomposition. The array 10 exhibits the following characteristics which typify systolic arrays:

(a) nearest-neighbor cell interconnections form rows and columns;

(b) many of cells (ie internal cells) have like signal processing functions;

(c) each cell performs its processing function on each system clock cycle; and

(d) signal flow is generally down columns and along rows of the array.

Systolic arrays suffer from the major disadvantage of requiring large numbers of processing cells, such as internal cells 12 in particular. To perform a QR decomposition on the data matrix X and associated residual extraction involving the vector y, the array 10 employs a linear chain of fifteen boundary cells 14 and a triangular sub-array of one hundred and twenty internal cells 12. The internal cells 12 form a 15×15 sub-array, and the array 10 as a whole is a 16×16 array. This arises from the fifteen-dimensional nature of the data matrix X and the one-dimensional nature of each element of the vector y. Generally, the number of cells required in a systolic array grows as the square of the number of dimensions of the computation to be performed. In a version of the array 10 appropriate for an n-dimensional data matrix X, n(n+1)/2 internal cells 12 would be required. Each cell is of the order of complexity of a microprocessor having floating point arithmetic capability, and requires the ability of a transputer to communicate with up to four neighbours. For computations where n is in the order of 100 or greater, the number of cells is of order 10⁴ or more. The cost and bulk of such an array is therefore unacceptably large for many purposes.

Referring now to FIG. 4, there is shown a processor 40 of the invention. The processor 40 incorporates eight processing units P₁ to P₈ with respective associated two-port memories M₁ to M₈. The unit P₁ is also associated with a two-port memory M₀. The units P₁ to P₈ are connected to respective decoders D₁ to D₈ and input/output ports I/O₁ to I/O₈. The input/output ports I/O₁ to I/O₈ are shown in simplified form to reduce illustrational complexity, but will be described in more detail later. Each is arranged to accept up to four digital words simultaneously in parallel, and to transfer them serially to a corresponding processing unit P₁ to P₈. They also provide for serial word output.

The ith processing unit P_(i) (i=1 to 8) is associated with a respective data bus B_(i) and memory address bus A_(i). The ith address bus A_(i) connects processing unit P_(i) to memories M_(i) and M_(i-1). Each of the input-output ports I/O₁ to I/O₈ has complex read/write and data input/output connections (not shown) to external circuitry. These will be illustrated in detail later. In FIG. 4, they are indicated schematically by respective buses 41₁ to 41₈. The ith data bus B_(i) connects processing unit P_(i) to memories M; and M.sub._(i-1), to port I/O_(i) and to a block of word registers indicated generally by 42. The register block 42 incorporates three sections 42₁ to 42₃ each of four registers R₁₁ to R₃₄, the ith section 42_(i) (i=1 to 3) consisting of registers R_(i1) to R_(i4). The block 42 also includes a fourth section 42₄ consisting of one register R₄₁. Each register R_(ij) is shown with a single or double arrow indicating its input side (left or right) and the number of digital words stored; ie single and double arrows correspond to one and two stored words respectively. Each register is a first in, first out (FIFO) device. Registers R₁₁, R₂₁, R₃₁ and R₄₁ are one word devices receiving input from the left and providing output to the right. Register inputs and outputs are unreferenced to reduce illustrational complexity. Registers R₁₂, R₂₂ and R₃₂ are also one word devices, but input from the right and output to the left. Registers R₁₃, R₁₄, R₂₃, R₂₄, R₃₃ and R₃₄ are two word devices which input from the left and output to the right.

The ith section of registers 42_(i) (i=1 to 4) is connected to data bus B_(9-i) to its left, each register having a respective bus branch connection. The upper three registers (eg R₃₂ to R₃₄) of the ith section 42_(i) (i=1 to 3) are connected to data bus B_(i+1) (eg B₄) to their right. However, the lowermost register R_(i1) in the ith section 42_(i) (i=1 to 4) is connected to data bus B_(i).

The processing units P₁ to P₈ have respective read-write output lines R/W₁ to R/W₈ connected to ports I/O₁ to I/O₈, associated memories M₀ -M₁ to M₇ -M₈ and registers R₁₁, R₁₂ to R₂₁ etc. The lines R/W₁ etc are each two bits wide as indicated by /2. The units P₁ to P₈ are also connected to their respective decoders D₁ to D₈ by three-bit chip address lines C₁ to C₈ marked /3.

Each of the decoders D₁ to D₈ has seven one-bit output lines such as D₂ lines 44 for example, and these lines are connected to respective memory, I/O port and register devices M₁, I/O₁, R₁₁ etc. Some decoder lines such as those at 46 of D₅ are surplus to requirements. These are left unconnected as indicated by X symbols. X symbols also indicate unconnected buses below memories M₀ and M₈.

The mode of operation of the processor 40 as compared to that of the prior art device 10 is illustrated in FIG. 5. In this drawing, conceptual locations of internal cells 12 in the device 10 are indicated as rectangles such as 50. The scale of the drawing is vertically foreshortened for illustrational convenience. Each of the processing units P₁ to P₈ executes the computational tasks of a respective fifteen internal cells 12. In accordance with this, each rectangle 50 incorporates within it a number indicating the associated processing unit; ie rectangles 50 (and the internal cells 12 they represent) referenced internally with the numeral i (i=1, 2, . . . 7 or 8) are associated with processing unit P_(i). Each rectangle also has external upper left and lower right indices V1 and V2 respectively, where V1 is in the range 1 to 15 and V2=V1+15 in each case. V1 and V2 respectively correspond to the first and second intervals in time at which the relevant processor in each case carries out the function of the internal cell associated with the location. The drawing also includes diagonal lines representing memories M₀ to M₈. Dotted lines 52 link different regions associated with respective common memories. Locations representing register sections are indicated by multi-cornered lines with like references 42₁ to 42₄.

In operation, each processing unit P_(i) executes in sequence processing tasks which would be carried out by a respective fifteen internal cells 12 in the prior art. A cycle of operation of the prior art systolic array 10 therefore requires fifteen cycles of the processor 40 of the invention. The latter will be referred to as subcycles. Subcycles 1 to 15 consequently correspond to cycle 1, subcycles 16 to 30 to cycle 2 and so on. Numerals V1 and V2 in FIG. 3 are subcycle numbers. On subcycles or V1 values 1 to 15, processing unit P₁ executes the processing functions of internal cells located in the lower sections of the two lowest diagonals of the array 10, as indicated by numeral 1 within corresponding rectangles 50 in FIG. 5. Unit P₁ begins on subcycle 1 with a computation corresponding to the function of that internal cell 12 in the centre of the lowest diagonal of the array of cells, as indicated by an upper left V1 value of 1. On subcycle 2, as indicated by V1=2, unit P₁ carries out a first cycle computation corresponding to the lowermost internal cell 12 in the final (rightmost) column. On subcycle 3, the computation is that of the internal cell 12 in the penultimate (second lowest) row and final column. This procedure is repeated on successive subcycles, the conceptual location of the processing operation reducing by one in row or column position alternately. After subcycle 15, ie after the end of cycle 1, the computation executed is that of the lowest internal cell at the center of the lowest diagonal once more, as indicated by V2=16, and thereafter the sequence repeats to implement cycle 2. Similar processing sequences are executed by processing Units P₂ to P₈. Units P₂, P₃ and P₄ carry out computations corresponding to respective pairs of part minor diagonals. The equivalents for units P₅, P₆ and P₇ are two respective complete minor diagonals together with two respective part minor diagonals. For unit P₈, there is a single upper right location and the upper parts of diagonals having lower parts associated with P₁.

Each of the units P₁ to P₈ reads from and writes to respective memories among M₀ to M₈ and register sections 42₁ to 42₄. Memories and registers are illustrated in FIG. 5 adjacent the conceptual internal cell locations to which they are interfaced. For example, throughout each cycle processing unit P₁ communicates with memories M₀ and M₁, but also communicates with register section 42₁ on subcycle 1 (ie one subcycle per cycle). Unit P₂ communicates with register section 42₁ on subcycle 1 and both register sections 4₂₁ and 42₂ on subcycle 3.

The mode of operation of the processor 40 of the invention will now be described in more detail with reference to Table 1 and FIG. 6 to 8. Parts in FIGS. 6 to 8 and Table 1 which were described earlier are like referenced. FIG. 2 illustrated each internal cell 12 receiving input of three quantities c, 5 and x_(in), performing a computation and generating outputs c, s and x_(out). This is re-expressed in FIG. 6 as three read operations RE1 to RE3 and three write operations WR1 to WR3. In FIG. 7, the nth processing unit Pn (n=1, 2, . . . 7 or 8) is shown connected between memories M_(n-1) and M_(n). It incorporates processing logic responsive to a stored program in local (ie internal) memory which also contains a data address look-up table and a coefficient store. The look-up table is a list of fifteen address sets, ie. one set per subcycle. The coefficient store has space for fifteen updatable coefficients of the kind r, and for temporary storage of a value for which an output delay is required. In FIG. 8, the lower right hand region of FIG. 5 is shown on an expanded scale. Memories M₀ to M₃ are shown subdivided into individual address locations labelled with integers. Not all address locations illustrated are employed. As in FIG. 5, in FIG. 8 each processing unit P₁ to P₃ (indicated by the relevant numerals within boxes) h as an upper left numeral indicating subcycle number. In Table 1, addresses in memories M₀ to M₃ are given for read and write operations in processing units P₁ to P₃ on subcycles 6 and 7. Addresses shown in FIG. 8 and Table 1 are in the range 0 to 22 for illustrational convenience, although in practice a typical memory address space would be 256 (8 bits) or greater.

As has been said, processing begins on subcycle 1, the first subcycle of the first cycle. However, it turns out that the first subcycle of each cycle is in fact a special case. In consequence, read/write operations on subcycles 2 onwards will first be describe d as being typical , and those of subcycle 1 will be discussed later.

Processing unit P₁ operates as follows. Referring to FIGS. 4, 7 and 8 once more, for each subcycle the stored program in local memory has three successive read instructions; each of these requires data to be read from three data addresses of a respective address set stored in the local memory look-up table and corresponding to the current subcycle of operation. The look-up table also stores values for the chip address lines C₁, which are equivalent to a three-bit extension of the address bus A₁. In Table 1, M_(n) Z designates address Z in memory M_(n). On subcycle 2, the read operations RE1, RE2 and RE3 for processing unit P₁ are from addresses M₁ 0, M₀ 8 and M₀ 7 respectively. The unit P₁ places an address on address bus A₁ corresponding to Z=0, and places a three-bit code on chip address lines C₁ providing for M₁ to be enabled by decoder D₁ and for M₀, R₁₁ and I/O₁ to be disabled. It also places a two-bit "read" code on read/write line pair R/W₁ to signify a read operation. This causes memory M₁ to place the contents of its address 0 on the data bus B₁, where it is read by processing unit P₁ as RE1 and temporarily stored, Unit P₁ then changes the code output at C₁ to that required for decoder D₁ to enable M₀, and changes the address on bus A₁ to Z=8 and subsequently to Z=7. This provides for successive read operations RE2 and RE3 from addresses 8 and 7 of M₀.

Having carried out three read operations in succession on subcycle 2, unit P₁ executes the internal cell computations shown in FIG. 2 to generate x_(out) and r (updated) for the second conceptual internal cell with which it is associated. It replaces its internally stored value of the second of fifteen coefficients r (initially zero) by r (updated), and is then ready to output the newly computed x_(out) together with two unchanged input values (c, s input as RE2, RE3). On subcycle 2, unit P₁ performs the function of the lowermost internal cell 12 of FIG. 1, which provide c, s and x_(out) signals to destinations outside the internal cell sub-array. In the processor 40, this situation is implemented by write operations to an input/output port. The processing unit P₁ consequently executes three successive write operations to port I/O₁. It obtains from its look-up table the next three chip address codes. These are in fact the same code, that required to access port I/O₁ and for which no address on bus A₁ is needed. They form the second half of the first address set. Unit P₁ places on chip address lines C₁ the chip address code obtained from the look-up table. This activates decoder D₁ to enable port I/O₁, and unit P₁ subsequently places a two-bit "write" code on line pair R/W₁ and places values x_(out), c and s in succession on data bus B₁ as WR1, WR2 and WR3 respectively. This routes the values to subsequent signal processing circuitry (not shown) interfaced to port I/O₁.

Subcycle 2 ends when WR3 has been output, and processing unit P₁ proceeds to implement the subcycle 3 functions. These require reading from M₁ 5, M₀ 10 and M₀ 9, and writing to M₁ 0 (WR1) and I/O₁ (WR2 and WR3), which form the third address set of unit P₁. The WR1 function overwrites the contents of M₁ 0 read on the preceding subcycle. Unit P₁ also computes and internally stores an updated R-matrix element r appropriate to its third associated internal cell location (V1=3). On later subcycles, as shown in FIG. 8, the read and write operations are to and from memory addresses in M₀ and M₁. Table 1 gives the read and write memory addresses in M₀ to M₃ and port I/O₃ for processing units P₁ to P₃ on subcycles 6 and 7.

Processing unit P₁ reads from memories M₀ /M₁ and writes to those memories and/or port I/O₁ exclusively during subcycles 2 to 15. On subcycle 1 however, as indicated in FIG. 5, it is interfaced with register section 42₁ immediately above. As shown in FIG. 6, RE1 is read from above. It is therefore received from register R₁₁ of register section 42₁ in response to an enable signal from decoder D₁. Register R₁₁ receives input from the eighth processing unit P₈ on later cycles.

Subcycle 1 is a special case In the operation of processing unit P₁. So also are subcycles 16, 31 etc, ie the first subcycle of each cycle and numbered (15(n-1)+1), n=1, 2, 3 etc. These are also special case for the other processing units P₂ to P₈. The reason is as follows. In the simulated systolic array 10, data and result flow is downwards and to the right. It progresses at the rate of one cell per clock cycle along rows and down columns. An internal cell having a neighbor to its left or above receives data from the neighbor which the neighbor used or computed one cycle earlier. In the processor 40 however, as shown In FIG. 5, a processing unit (P₁ etc) proceeds conceptually upwards and to the left on successive subcycles in the reverse of the systolic array data flow direction. In consequence of this, inputs to a processing unit P₁ etc from a neighboring location arc not generated one cycle earlier, but instead one cycle minus one subcycle earlier. For most of each cycle this difference is immaterial, However, on subcycle 1 (and later equivalents) the right hand neighboring location corresponds to subcycle 15; ie these two subcycles are the beginning and end of the same first cycle. The right hand location (V1=15, V2=30) is fourteen subcycles behind the left hand location (V1=1, V2=16) in this special case, instead of being one subcycle ahead as elsewhere in the cycle. In consequence, in the absence of arrangements to the contrary, right hand outputs (values c, s output as WR2, WR3) from processing unit P₁ on subcycle 1 of the first cycle would be used as inputs on subcycle 15 of the first cycle. Similarly, the vertical output (x_(out) =WR1) from processing unit P₁ on subcycle 1 to memory M₀ would occur too early. This would conflict with the systolic array processing requirement that a result generated by a processing cell on one cycle is to be employed by a neighbor to its right or below on the succeeding cycle. Similar remarks apply to all other processing units P₂ to P₈.

To deal with this timing problem, on the first subcycle of each cycle, ie subcycle (15(n-1)+1), n=1, 2, 3 etc, the processing units P₁ to P₈ store internally their current values of x_(out), c and s. They each output as WR1, WR2 and WR3, the respective values of x_(out), c and s which they stored on the preceding cycle (if any). In consequence, on (and only on) the first subcycle of each cycle, outputs from the processing units P₁ to P₈ are delayed by one cycle. This involves an additional three storage locations in each processing unit's Or internal coefficient store.

At the end of subcycle 15, the first cycle of operations of unit P₁ is complete and subcycle 16 begins the second cycle (V2=16 to 30). As shown in FIG. 5, processing unit P₁ reverts to execution of the computation of the internal cell 12 at the centre of the lowermost diagonal. On cycle 2 (subcycles 16 to 30) the unit P₁ reads in data (if any) stored in memories M₀ and M₁ and register R₁₁ during cycle 1. It temporarily stores three data values to implement a one cycle delay. It also stores fifteen values of r in the process of updating, each r corresponding to a respective prior art internal cell.

Similar remarks apply to other processing units P₂ to P₈ and to later cycles. In general, a processing unit P_(n) reads from and writes to its associated memories M_(n-1) and M_(n) (n=1 to 8) for most of a cycle. Exceptions to this are as follows. Units P₅ to P₈ execute RE1 (x_(in)) from respective ports I/O₅ to I/O₈ when performing computations corresponding to internal cells 12 in the uppermost row of the FIG. 1 prior art array 10. Units P₅, P₆ and P₇ are in this situation on four subcycles of each cycle (eg unit P₅ on subcycles 6 to 9 of cycle 1), but unit P₈ only three. This "uppermost" RE1 operation is equivalent to input of an element of a data matrix X (see FIG. 3) to an array 10. All eight processing units P₁ to P₈ execute processing functions corresponding to internal cells in extreme right hand column locations at respective points in each cycle. Units P₁ to P₇ are in this situation for two subcycles per cycle, whereas the equivalent for unit P₈ is only one subcycle. When in this situation, the units P₁ to P₈ execute WR2 and WR3 to respective ports I/O₁ to I/O₈ ; P₁ executes WR1 to I/O₁ also for one of its two subcycles in this situation as previously described. This extreme right hand output function corresponds to output from the prior art internal cell sub-array of FIG. 1., Finally, a processing unit P_(i) (i=1 to 8) reads from or writes to units P_(10-i) and/or P_(9-i) via the intervening register block 42. Each register such as R₁₂ or R1₃ is a one or two word temporary storage device arranged on a first in, first out (FIFO) basis, as has been said. The registers R₁₁ to R₄₁ provide for communication between processing units which either do not share a common memory or require additional storage to avoid simultaneous memory addressing by two units. For example, as shown in FIG. 5, on each of subcycles. 3 and 5 processing unit P₃ performs two read operations RE2 and RE3 from unit P₇ via registers R₂₃ and R₂₄ of register block 42₂. On subcycle 3, unit P₃ reads the first stored words in registers R₂₃ and R₂₄, and on subcycle 5 it reads the succeeding words stored therein. It also reads the contents of R₃₁ as RE1 and writes to R₂₂ as WR1 on subcycle 5. Other read/write operations are to and from memories M₂ and M₃. Similar remarks apply to other pairs of processing units interfaced together via the register block 42.

The processing units P₁ to P₈ operate in synchronism under the control of an external clock (not shown). This is similar to prior art systolic arrays and will not be described. As illustrated and described with reference to FIGS. 5, 6 and 8, the phasing of the read and write operations of the processing units P₁ to P₈ is arranged to ensure that each of the memories M₀ to M₈ is required to respond only to a single address input at any time. For example, on subcycle 5 in FIG. 8, units P₁ and P₂ carry out read-write operations to memories M₀ /M₁ and M₁ /M₂ respectively, which could cause a clash in access to M₁. However, unit P₁ begins (REI) by reading from M₁ when unit P₂ is reading from M₂.

Consequently, the P₁ RE2 and RE3 operations are both from M₀, at which time P₂ has switched to addressing M₁. This phasing of read operations avoids memory address conflict. Similar remarks apply to write operations and processing units P₃ to P₈ and memories M₃ and M₈. A read operation is at the beginning of any subcycle and a write operation is at the end. A memory (eg. M₁) may consequently experience read and write operations on the same subcycle without conflict of addresses on an address bus (eg A₂); however, in general two simultaneous operations involving a single memory must be avoided. It is of course possible to accommodate such conflict at the expense of duplication of address buses and memories.

Referring now also to FIG. 9, in which parts previously described are like-referenced, the structure of each of the input/output ports I/O₁ to I/O₈ is shown in more detail. Subscript indices to references (eg 1 in I/O₁) are omitted to indicate all parts of the relevant type, are referred to. The port I/O incorporates a four-word parallel-in/serial-out input register 60, together with a one-word parallel-in/parallel-out register 62. The input register 60 has four data input buses such as 64, and four write control inputs such as 66 connected to a common write line 68. The output register 62 has an output bus 70 and an associated read output line 72. The read/write fine pair R/W of FIG. 4 incorporates a read line 74 connected to the input register 60 and a write line 76 connected to the output register 62. The two-way data bus B is connected to both registers 60 and 62. The connections 64 to 72 inclusive were indicated to collectively by bus 41 in FIG. 4.

The port I/O operates as follows. Immediately prior to the first subcycle of each cycle of operation of the processor 40, the write line 68 of the input register 60 is pulsed, and four digital data words are applied simultaneously to respective register inputs 64. This overwrites existing register contents and loads the four words in the register 60 in a successively disposed manner. Each time the read line 74 is pulsed, the word associated with the right hand input 64 is placed on the data bus B, and the remaining words are shifted to the right. This provides for the four loaded words to be output on the data bus B one after the other in response to four successive read line pulses. Referring now also to FIG. 5 once more, it can be seen that processing unit P₆ requires to read data from I/O₆ when it is performing top row computations on subcycles (V2 values), 19, 20, 25 and 26. On each of these subcycles, the unit P₆ will send out a respective read pulse on line pair R/W₆, and requires a respective digital word to be placed on data bus B₆ by its input register 60 consisting of the correct matrix element x_(ij) of the data matrix X previously referred to. Unit P₆ deals with the 5th, 6th, 11th and 12th top row cell locations. Matrix elements of the kind x_(n),6, x_(n-1),7, x_(n-6),12 and x_(n-7),13 are therefore simultaneously input to the register 60 of unit P₆. Here n is a positive integer, and n-k less than or equal to zero is interpreted as x_(n-k),q equal to zero for all q. Input is at the end of the last (fifteenth) subcycle of each cycle as has been indicated. This ensures that the data is present to be read in over the next cycle by different processing units executing top row computations at different times. The processing unit P₆ reads in data words in reverse order (ie x_(n-7),13 leading) on two successive subcycles followed by a four subcycle gap then two further subcycles.

Similar remarks apply to input to processing units P₅, P₇ and P₈. Unit P₅ requires input from part I/O₅ on four successive subcycles, whereas three successive inputs from port I/O₈ suffice for unit P₈. Unit P₇ requires input from port I/O₇ on four subcycles of which the first and last pairs are separated by eight subcycles.

In practice, the input registers 60 of the processing units P₅ to P₈ are arranged and loaded in parallel; they receive data simultaneously once per cycle. This occurs immediately prior to processing unit P₈ computing the function of the uppermost and extreme right location (V1=1, V2=16) in FIG. 5. It simulates the prior art systolic array 10, which receives top row inputs simultaneously. The contents of the registers 60 are overwritten by each succesive input. As will be described later in more detail, meaningful data (ie x₁₂) is first processed by unit P₈ on subcycle 30, the data having been input at 60 prior to subcycle 16. Thereafter the data remains in the registers 60 until overwritten at the end of subcycle 30.

Output from the processor 40 via a port I/O of the kind shown in FIG. 9 is comparatively simple. A write pulse on the line 76 clocks the contents of data bus B into the output register 62. The read output line 72 is pulsed by external circuitry (not shown) to read the register contents on to the output bus 70. A succeeding write pulse at 76 provides for the register contents to be overwritten. External circuitry (not shown) is arranged to read from the output register 62 up to five times per cycle, this being the maximum number of output values per cycle from a single port I/O. In the present example of the invention, processing units P₁ to P₄ only require output facilities such as output register 62. However, it is convenient to treat all units P₁ to P₈ as having like I/O ports.

Referring to FIGS. 1 and 5 once more, it is useful to compare the operation of the prior art device 10 with that of the processor 40 of the invention. The device 10 employs signal flow progressing generally downwards and to the right, each of the cells 12 to 18 being clock activated and operating on every clock cycle in phase with one another. In the processor 40 of the invention, this scheme is at least conceptually preserved from cycle to cycle. Each processing; unit P₁ etc shown in FIG. 5 receives data from the equivalent of above and to the left and outputs to the equivalent of below and to the right. In the case of processing unit P₁ on subcycle 1 (V1=1), it receives from register section 42₁ "above" and memory M₀ "to the left". It subsequently provides (internally delayed) outputs "below " and "to the right " via memory M₀, the outputs to the right being for use on the next cycle (subcycle 16=V2). However, within a cycle, each of the processing units P₁ to P₈ deals with the conceptual internal cell locations allocated to it in reverse order compared to prior art data flow. Thus the first locations to be processed are those lying on an upper right to lower left diagonal (V1=1). Locations are processed in succession upwardly and to the left; eg processing unit P₁ executes computations corresponding to internal cell locations in which the row and column numbers reduce alternately by unity between successive subcycles. For units P₅ to P₈ , a discontinuous shift occurs after top row subcycles. On subcycle 1, the computations of units P₃ to P₈ correspond to internal cell locations on an array diagonal extending to the upper right hand corner. Unit P_(i) on subcycle 15 is processing the internal cell location at row (9-i), column (8+i) (i=1 to 7) in FIG. 5. (For comparison with FIG. 1, the column number should be increased by 1 to allow for the extra column incorporating the uppermost boundary cell 14.) On subcycle 1, the equivalent for i=1 to 8 is column (7+i) with unchanged row number (9-i).

The reason for the conceptual reversing of the order of processing internal cell locations as indicated in FIG. 5 is to ensure that intermediate computed values stored in memories or registers are not overwritten before they are needed. For example, referring to FIG. 8 once more, on subcycle 3 processing unit P₁ overwrites the contents of address M₁ 0 which it read on the previous subcycle. The new value written to address M₁ 0 remains there to be read and then overwritten on the subsequent cycle fourteen subcycles later. If this procedure were to be reversed, the contents of address M₁ 0 would be overwritten before being read during a cycle. In this connection it is emphasised that each of the processing units P₁ to P₈ employs inputs generated on the preceding cycle and required to be unaffected by intervening computations. To avoid unwanted overwriting of stored data without the aforesaid order reversal, it would be necessary to provide storage (double buffering)- and address and data buses additional to that shown in FIG. 4.

The conceptual reversal of the location processing order and the relative phasing of the operations of the processing units P₁ to P₈ is implemented by the respective list of data addresses in each processing unit as illustrated in FIG. 7. The addresses in any list are accessed in succession, and when a processing unit reaches the end of its list it begins again. The relative phasing illustrated in FIG. 5 is implemented by assigning the processing units P₁ to P₈ appropriate start points for their respective address lists.

The foregoing analysis relating to FIGS. 4 to 9 has not referred to the matter of processor start-up. It was assumed implicity that, from V1 value or subcycle 1 onwards, the processor 40 was processing data. In the prior art, as shown in FIGS. 1 to 3, it takes 15 cycles after input of x₁₁ to the topmost boundary cell 14 for y₁ to be input on cycle 16 to the internal cell 12 in the upper right corner. A further fourteen cycles are required for a cumulatively processed result arising inter alia from y₁ to reach the lowermost internal cell 12. The start-up phase for a prior art systolic array 10 consequently passes as a wavefront from upper left down to lower right, the wavefront extending orthogonally to its propagation direction. An equivalent start-up phase occurs in the processor 40 of the invention. The first processing unit to operate on meaningful input data is P₈ on subcycle 30 at the top left hand corner of FIG. 5. Subcycle 30 is at the end of the second cycle during which x₁₂ is to be input to processing unit P₈. On this subcycle, unit P₈ is carrying out the processing task of the first (leftmost) top row internal cell 12 shown in FIG. 1, which receives successive matrix elements of the kind x_(n2) (n=1, 2 . . . ). On subcycles 44 and 45, which are in the cycle (not shown), unit P reads in x₁₃ and x₂₂ respectively to carry out the functions of the first and second top row internal cells 12 of FIG. 1. This start-up phase proceeds along rows and down columns in the FIG. 5 representation. Eventually, on subcycle 437, the second subcycle of cycle 30, processing unit P₁ receives inputs derived from x₁₁ to x₁,15 and y₁. It computes a result corresponding to the first meaningful output from the lowermost internal cell 12 in the FIG. 1 processor 10. The start-up phase is then complete. Start-up phases are well understood in the fields of systolic arrays and digital electronics and will not be described further. It may be desirable to make provision for ignoring or inhibiting those outputs from the processor 40 which do not correspond to real inputs.

The processor 40 requires an equivalent of the chain of boundary cells 14 and delay latches 16 in order to operate on a data matrix X. It is necessary to compute parameters c and s from values output by processing units P₁ and P₈, and temporarily stored in memories M₀ and M₈ for use one cycle later in each case. This is exemplified in FIG. 8 for example on subcycle 6. On this subcycle, unit P₁ executes WR1 to M₀ 17; ie address 17 in memory M₀ receives the equivalent of a vertical output of an internal cell 12 destined for a boundary cell 14. The memory M₀ is therefore required to be interfaced to a device which will access M₀ 17, compute c and s rotation parameters as shown in FIG. 2, and write c and s to M₀ 14 and M₀ 13 respectively for use on the next cycle. This is to be carried out on alternate subcycles, ie each occasion that unit P₁ is shown closely adjacent to memory M₀ in FIG. 5. Similarly, memory M₈ is required to be interfaced to a second like device arranged to access it on alternate subcycles for computation and return of rotation parameters. This second like device is required to receive matrix element x₁₁ on the first cycle of operation as indicated in FIGS. 1 and 3. It is also required to receive subsequent row leading matrix elements x_(n1) (n=2,3 . . . ). It will act as the uppermost boundary cell 14 in FIG. 1 to generate c and s rotation parameters to be read as RE2 and RE3 by processing unit P₈ at the end of the second cycle (V1=30). These devices are straightforward to implement in practice. They will be processing devices similar to units P₁ to P₈ and interfaced to respective memories M₀ and M₈ via the data and address buses shown truncated in FIG. 4.

The processor 40 of the invention incorporates processing units P₁ etc with internal memory containing an address look-up table and a store for three delayed values and fifteen coefficients in addition to a program. It is also possible to employ simpler processing devices with less internal memory capacity. In this case, the memories M₀ etc might contain address lists and value and coefficient stores, and be associated with counters for counting through address lists of respective processing devices. It may however be less convenient to implement and result in slower processing. This is because commercially available discrete processing devices such as transputers incorporate sufficient internal memory for the purposes of the processing units P₁ etc, and it would be inefficient not to use such facilities. However, the processor 40 might well be implemented as an integrated circuit chip or wafer in which individual processing units, registers and memories become respective areas of silicon or gallium arsenide. In this case the most convenient balance between local and remote memory may be chosen.

The processor 40 is designed for the situation in which eight processing units P₁ to P₈ carry out the functions of one hundred and twenty internal cells 12. In general, a triangular sub-array having n internal cells per (nondiagonal) outer edge has n(n+1)/2 cells. This number may be factorised either as n12 and (n+1) or as n and (n+1)/2. Since n is a positive integer, one of n and (n+1) must be an even number. Consequently, n(n+1)/2 can always be factorised to two whole numbers, one of which may be treated as the number of processing units and the other the number of internal cells allocated to each processing unit. However, it may be necessary for there to be an odd number of processing units, as opposed to the even number (eight) employed in the processor 40.

Referring to FIG. 10, there is shown an alternative form of processor of the invention, this being indicated generally by 140 and incorporating an odd number (seven) of processing units. Parts in FIG. 10 equivalent to those illustrated in FIG. 4 have like reference characters P, M, D or R with asterisks. Subscript indices are changed to run from 1 to 7 instead of 1 to 8. The processor 140 is very similar to that described earlier, and will not be described in detail. Instead, it is observed that the only substantial difference between the processor 140 and the earlier embodiment is that the former has no direct equivalent of processing unit P₄. It has no direct equivalents of M₄, D₄ and R₄₁ in consequence. Units P₄ ^(*) to P₇ ^(*) are in fact equivalent to units P₅ to P₈ respectively.

FIG. 11 shows the relative phasing of operation of the processing units P₁ ^(*) in terms of V1 and V2 values as before. It is referenced equivalently to FIG. 5. and shows that the processor 140 performs the function of a 13×13 triangular sub-array; ie n(n+1)/2 is 13×7 or 91. Each of the seven processing units P₁ ^(*) to P₇ ^(*) corresponds to thirteen internal cells as shown in the drawing. There are accordingly thirteen subcycles per cycle. In other respects, the processor 140 operates equivalently to the earlier embodiment and will not be described in detail.

Comparison of the regular structures of FIGS. 4 and 11 demonstrates that the invention may be constructed in modular form by cascading integrated circuit chips. Each chip could contain two (or more) processing units such as P₂ and P₈ together with their associated registers R₁ 1 to R₁₄, memories M₂ and M₈ etc. Processing units surplus to requirements on part-used chips would be bypassed. The processors 40 and 140 each employ one more memory M₀ /M₀ ^(*) than there are processing units P₁ etc. This may be accommodated by the use of an extra external memory rather than a largely bypassed integrated circuit. Alternatively, it is possible to omit M₀ and connect buses A₁ /B₁ to M₈. This provides for units P₁ and P₈ together with rotation parameter computing means (previously mentioned) to address a common memory M₈. Similar remarks apply to M₀ ^(*) /M₈ ^(*). may constitute a cumbersome alternative, since it imposes substantial access requirements on memory M₈ or M₈ ^(*).

The foregoing discussion was directed to the use of n/2 or (n+1)/2 processing units to carry out the function of an n×n triangular array of n(n+1)/2 processing units. This may frequently be an optimum implementation, since it combines a substantial reduction in the number of processing units required with a comparatively high degree of parallelism. It should be at least n/2 times faster than a single computer carrying out the whole computation, while employing 1/(n+1) of the number of processing units required for a fully parallel array employing one unit per node as in FIG. 1. However, the invention is not restricted to n/2 or (n+1)/2 processing units simulating an n×n triangular array. FIG. 12 illustrates appropriate phasing of operation for four processing units simulating a 16×16 triangular array. V1 and V2 values up to 68 are given.

A processor of the invention may be arranged to simulate both non-triangular systolic arrays and also arrays in which there are processing cells with differing computational functions. Individual cells may have more than one such function; eg a cell may switch between two computational functions on successive subcycles. For most purposes, however, such an arrangement might be undesirably complex. 

We claim:
 1. A digital data processor for simulating operation of a parallel processing array, the processor including an assembly of digital processing devices connected to data storing means, wherein:(a) each processing device is programmed to implement a respective list of sets of storing means data addresses; (b) each address set contains input data addresses and output data addresses said input data addresses are different from said output data addresses in each address set, and each address set corresponds to data input/output functions of a respective simulated array cell; (c) each list of address sets corresponds to a respective sub-array of cells of the simulated array, and each such list contains pairs of successive address sets in which the leading address sets have input data addresses which are the same as output data addresses of respective successive address sets, each list being arranged to provide for operations associated with simulated cells to be executed in reverse order to that corresponding to data flow through the simulated array; and (d) each processing device is programmed to employ a respective first address set from said respective list to read input data from input data addresses in said respective first address set and to write output data to output data addresses in said respective first address set, the output data being generated in accordance with a computational function, to employ subsequent address sets in said respective lists in succession in a like manner until the list is complete, and then to repeat this procedure cyclically using said respective list repeatedly.
 2. A digital processor according to claim 1, wherein each processing device is arranged to communicate with not more than four other processing devices, and incorporating storing means including register devices and memories connected between respective pairs of processing devices, the address set lists being such that each register device and memory is addressed by not more than one processing device at a time.
 3. A digital processor according to claim 2, wherein at least some of the processing devices are arranged to communicate with two of the other processing devices via respective register devices and with a further two of the other processing devices via respective memories, and wherein the address set lists are arranged such that the register devices are addressed less frequently than the memories.
 4. A digital processor according to claim 1, wherein at least some of the processing devices include input means arranged for parallel to serial conversion of input data elements.
 5. A digital processor according to claim 1, wherein each processing device is arranged to store and update a respective coefficient in relation to each address set in its list. 